{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-30 17:37:51.116160: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on Server/PC\n"
     ]
    }
   ],
   "source": [
    "# Importing PlaidML. Make sure you follow this \n",
    "import os\n",
    "try:\n",
    "    import plaidml.keras\n",
    "    plaidml.keras.install_backend()\n",
    "    os.environ[\"KERAS_BACKEND\"] = \"plaidml.keras.backend\"\n",
    "    from keras import backend as K\n",
    "    # example of training a gan on mnist\n",
    "    import keras\n",
    "    from keras.optimizers import Adam\n",
    "    from keras import Sequential\n",
    "    from keras import layers\n",
    "    from keras.layers import Dense\n",
    "    from keras.layers import Reshape\n",
    "    from keras.layers import Flatten\n",
    "    from keras.layers import Conv2D\n",
    "    from keras.layers import Conv2DTranspose, MaxPooling2D, UpSampling2D, ZeroPadding2D, Cropping2D\n",
    "    from keras.layers import LeakyReLU\n",
    "    from keras.layers import Dropout\n",
    "    from keras.models import load_model\n",
    "    from keras.callbacks import EarlyStopping\n",
    "    from keras.callbacks import ModelCheckpoint\n",
    "    #------------------------------\n",
    "    print(\"Running on MAC OS\")\n",
    "except:\n",
    "    from tensorflow.keras.optimizers import Adam\n",
    "    from tensorflow import keras\n",
    "    from tensorflow.keras import Sequential\n",
    "    from tensorflow.keras import layers\n",
    "    from tensorflow.keras.layers import Dense\n",
    "    from tensorflow.keras.layers import Reshape\n",
    "    from tensorflow.keras.layers import Flatten\n",
    "    from tensorflow.keras.layers import Conv2D\n",
    "    from tensorflow.keras.layers import Conv2DTranspose, MaxPooling2D, UpSampling2D, ZeroPadding2D, Cropping2D\n",
    "    from tensorflow.keras.layers import LeakyReLU\n",
    "    from tensorflow.keras.layers import Dropout\n",
    "    from tensorflow.keras.models import load_model\n",
    "    from tensorflow.keras.callbacks import EarlyStopping\n",
    "    from tensorflow.keras.callbacks import ModelCheckpoint\n",
    "    from tensorflow.keras.optimizers import Adam\n",
    "    print(\"Running on Server/PC\")\n",
    "    #------------------------------------------\n",
    "\n",
    "\n",
    "import os\n",
    "from os.path import exists as file_exists    \n",
    "\n",
    "# Libraries\n",
    "import glob\n",
    "import csv\n",
    "import json\n",
    "import math\n",
    "import joblib\n",
    "#------------------------------\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "# import visualkeras\n",
    "\n",
    "# Metric\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import roc_auc_score, roc_curve\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler \n",
    "#------------------------------\n",
    "\n",
    "import scipy\n",
    "from scipy.cluster import hierarchy as sch\n",
    "from scipy.cluster.hierarchy import dendrogram\n",
    "#--------------------------------------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#--------------- Create Folders -------------\n",
    "def ensure_dir(file_path):\n",
    "    directory = os.path.dirname(file_path)\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "        print(f\"Directory created!\\n{directory}\")\n",
    "def find_r_from_z (data):\n",
    "    return np.tanh(data)\n",
    "\n",
    "def find_z_from_r (data):\n",
    "    return np.arctanh(data)\n",
    "\n",
    "def rename_sigids(dataframe):\n",
    "    new_list = {}\n",
    "    try:\n",
    "        list_of_sigs = list(dataframe.columns)\n",
    "        dtype = 'df'\n",
    "    except:\n",
    "        list_of_sigs = list(dataframe).copy()\n",
    "        dtype = 'list'\n",
    "        \n",
    "    for sig in list_of_sigs:\n",
    "        sigs = sig.split(\"_\")\n",
    "        if len(sigs) != 5:\n",
    "            new_list[sig] = sig\n",
    "        else:  \n",
    "            sig_no = sigs[1]\n",
    "            id_no = sigs[-1]\n",
    "            if dataset == 'syncan':\n",
    "                new_list[sig] = f\"S:{sig_no.zfill(1)}_ID:{id_no.zfill(2)}\"\n",
    "            else:\n",
    "                new_list[sig] = f\"S:{sig_no.zfill(1)}_ID:{id_no.zfill(4)}\"\n",
    "\n",
    "            \n",
    "    if dtype == 'list':\n",
    "        return list(new_list.values())\n",
    "    else:\n",
    "        dataframe = dataframe.rename(columns=new_list)\n",
    "        dataframe = dataframe.rename(index=new_list)\n",
    "        return dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ambient files are:\n",
      " ['ambient_dyno_exercise_all_bits', 'ambient_dyno_drive_basic_short', 'ambient_dyno_reverse', 'ambient_dyno_drive_radio_infotainment', 'ambient_dyno_drive_benign_anomaly', 'ambient_highway_street_driving_long', 'ambient_dyno_idle_radio_infotainment', 'ambient_dyno_drive_winter', 'ambient_highway_street_driving_diagnostics', 'ambient_dyno_drive_extended_short', 'ambient_dyno_drive_basic_long', 'ambient_dyno_drive_extended_long'], etc.\n",
      "\n",
      "\n",
      "Attack files are:\n",
      " ['correlated_signal_attack_3_masquerade', 'max_speedometer_attack_2_masquerade', 'reverse_light_off_attack_1_masquerade', 'reverse_light_on_attack_3_masquerade', 'reverse_light_on_attack_2_masquerade', 'max_speedometer_attack_3_masquerade', 'correlated_signal_attack_2_masquerade', 'reverse_light_off_attack_2_masquerade', 'max_speedometer_attack_1_masquerade', 'correlated_signal_attack_1_masquerade', 'max_engine_coolant_temp_attack_masquerade', 'reverse_light_on_attack_1_masquerade', 'reverse_light_off_attack_3_masquerade'], etc.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# %%\n",
    "# Creating two lists of ambient and attack datasets\n",
    "cur_dir= os.getcwd()\n",
    "dataset = 'syncan'\n",
    "# dataset = 'road'\n",
    "\n",
    "\n",
    "# ambient_dirs = glob.glob(cur_dir+f\"//..//data//{dataset}//generated//ambients//*.csv\")\n",
    "# attack_dirs = glob.glob(cur_dir+f\"//..//data//{dataset}//generated//attacks//*.csv\")\n",
    "\n",
    "ambient_dirs = glob.glob(cur_dir+f\"//..//..//Workspace//data//{dataset}//generated//ambients//*.csv\")\n",
    "attack_dirs = glob.glob(cur_dir+f\"//..//..//Workspace//data//{dataset}//generated//attacks//*.csv\")\n",
    "\n",
    "# Creating two lists of file names \n",
    "ambient_files = [x.split(\"/\")[-1].split(\".\")[0][0:-10] for x in ambient_dirs]\n",
    "attack_files = [x.split(\"/\")[-1].split(\".\")[0][0:-10] for x in attack_dirs]\n",
    "\n",
    "print(f\"Ambient files are:\\n {ambient_files[0:]}, etc.\")\n",
    "print(f\"\\n\\nAttack files are:\\n {attack_files[0:]}, etc.\")\n",
    "\n",
    "# %%\n",
    "# ambient_files\n",
    "\n",
    "# %%\n",
    "# Defining parameters..........."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ambient_files =ambient_files[2:]\n",
    "ambient_files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x800 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "NameError",
     "evalue": "name 'corr_df_mean' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[7], line 98\u001b[0m\n\u001b[1;32m     95\u001b[0m plt\u001b[39m.\u001b[39mshow()\n\u001b[1;32m     97\u001b[0m \u001b[39m# Finalizing the corr mats.......................\u001b[39;00m\n\u001b[0;32m---> 98\u001b[0m corr_df_mean \u001b[39m=\u001b[39m (corr_df_mean\u001b[39m/\u001b[39m\u001b[39mlen\u001b[39m(ambient_files))\u001b[39m.\u001b[39mfillna(\u001b[39m0\u001b[39m)\n\u001b[1;32m     99\u001b[0m z_fisher \u001b[39m=\u001b[39m z_fisher\u001b[39m/\u001b[39m\u001b[39mlen\u001b[39m(ambient_files)\n\u001b[1;32m    100\u001b[0m corr_df_fisher \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mDataFrame(find_r_from_z(z_fisher))\u001b[39m.\u001b[39mfillna(\u001b[39m0\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'corr_df_mean' is not defined"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    del corr_df_mean, corr_df_max, z_fisher\n",
    "except:\n",
    "    pass\n",
    "\n",
    "\n",
    "# reading each dataset in a df file\n",
    "folder_name_data = \"Saved_Data\"\n",
    "folder_name_plots = \"overall\"\n",
    "\n",
    "ensure_dir(f\"{folder_name_data}//\")\n",
    "ensure_dir(f\"plots//{folder_name_plots}//\")\n",
    "\n",
    "if dataset == 'syncan':\n",
    "    fig, axes = plt.subplots(2, 2, figsize = (10,6))\n",
    "else:\n",
    "    fig, axes = plt.subplots(3, 4, figsize = (16,8))\n",
    "    \n",
    "axs = axes.flatten()\n",
    "df_scale = pd.DataFrame([])\n",
    "\n",
    "for indx, (file_name, file_dir) in enumerate(zip(ambient_files, ambient_dirs)):\n",
    "    ax = axs[indx]\n",
    "#     if file_name !=  'ambient_dyno_drive_basic_short':\n",
    "#         continue\n",
    "        \n",
    "    print(file_name)\n",
    "\n",
    "    try:\n",
    "        #Try loading corr mat.............\n",
    "#         regenerate\n",
    "        corr_df_new = abs(pd.read_csv(f\"{folder_name_data}//Corr_matrix_update_{file_name}.csv\" ,index_col=0).fillna(0))\n",
    "        print(f\"Loaded {file_name}\")\n",
    "        \n",
    "    except:\n",
    "        #Generate corr mat and store......\n",
    "        print(\"Loading dataset: \",file_name)\n",
    "        # Checking if the signalwise data already exists\n",
    "        X_train = pd.read_csv(file_dir, index_col = 0) \n",
    "\n",
    "        # Defining the number of signals..............................\n",
    "        X_train = X_train.copy()\n",
    "        X_train = X_train.drop(columns = ['Label', 'Time', 'ID']).copy()\n",
    "\n",
    "        if dataset == 'road':\n",
    "            # Forward filling algorithm........\n",
    "            print(\"Forward filling...\")\n",
    "            X_train = X_train.ffill().copy()\n",
    "            X_train = X_train.bfill().dropna()   \n",
    "            #--------------------------------\n",
    "            print(\"X_train.shape\", X_train.shape)\n",
    "            #------------------------------------\n",
    "        else:\n",
    "            print(\"No treatment needed for SynCAN!\")\n",
    "        \n",
    "        # Loading data..........................\n",
    "        # X_train = X_train.values\n",
    "        \n",
    "        #Saving scaler data.........................................\n",
    "        scaler_train = MinMaxScaler()\n",
    "        scaler_train.fit(X_train.values)\n",
    "        df_scale[f'{file_name}_max'] = list(scaler_train.data_max_)\n",
    "        df_scale[f'{file_name}_min'] = list(scaler_train.data_min_)\n",
    "        #............................................................\n",
    "\n",
    "        #Correlation matrix..........................................\n",
    "        corr_df_new = X_train[0::100].corr().fillna(0).copy()\n",
    "        #Saving corr mat.......................\n",
    "        corr_df_new.to_csv(f\"{folder_name_data}//Corr_matrix_update_{file_name}.csv\", index = True, header = True)\n",
    "        #Corr mat is loaded...........................................\n",
    "\n",
    "    try:\n",
    "#         print(\" Updating pixels..... 1\")\n",
    "        corr_df_mean += corr_df_new\n",
    "        col_list = corr_df_new.columns.to_list()\n",
    "        indeces = corr_df_new.loc[col_list,col_list] > corr_df_max.loc[col_list,col_list] \n",
    "        corr_df_max[indeces] = corr_df_new[indeces].copy()\n",
    "#         corr_df_max[corr_df_new > corr_df_max] = corr_df_new[corr_df_new > corr_df_max].copy()\n",
    "        z_fisher += find_z_from_r(corr_df_new.values)\n",
    "        \n",
    "    except Exception as e:\n",
    "        print('Failed to upload to ftp: '+ str(e))\n",
    "        print(\"*********** Adding new Corr *************\")\n",
    "        columns_list = corr_df_new.columns.tolist()\n",
    "        corr_df_mean = corr_df_new.copy()\n",
    "        corr_df_max = corr_df_new.copy()\n",
    "        z_fisher = find_z_from_r(corr_df_new.values)\n",
    "        \n",
    "    ax = sns.heatmap(corr_df_new, ax = ax, xticklabels=False, yticklabels=False)\n",
    "    ax.set_title(file_name)\n",
    "#     ax.tick_params(left=False, bottom=False) ## other options are right and top\n",
    "fig.suptitle(\"Correlation heatmaps of different files\")\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"plots//{folder_name_plots}//Corr_Heatmaps_{dataset}.jpg\", dpi = 350) \n",
    "plt.show()\n",
    "\n",
    "# Finalizing the corr mats.......................\n",
    "corr_df_mean = (corr_df_mean/len(ambient_files)).fillna(0)\n",
    "z_fisher = z_fisher/len(ambient_files)\n",
    "corr_df_fisher = pd.DataFrame(find_r_from_z(z_fisher)).fillna(0)\n",
    "corr_df_fisher.columns = corr_df_mean.columns\n",
    "corr_df_fisher.index = corr_df_mean.index\n",
    "\n",
    "try:\n",
    "    df_scale.index = X_train.columns\n",
    "    df_scale = df_scale.T.copy()\n",
    "    df_scale.to_csv(f\"Scalling_Data/min_max_values_{dataset}.csv\", header=True, index=True)\n",
    "    #.................................................\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig, axes = plt.subplots(4,5, figsize = (12, 4.5), sharex = True)\n",
    "# for sig, ax in zip(top_signals, axes.flatten()):\n",
    "#     X_train[sig][0:1000000].plot(ax = ax, marker = 'p', linestyle = '--', markersize= '0.5')\n",
    "#     ax.set_title(sig)\n",
    "#     ax.set_xlabel(\"Time Step\")\n",
    "# fig.suptitle(\"Time series plot of different signals\")\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(f\"plots//{folder_name_plots}//Time_series_{dataset}.jpg\", dpi = 350) \n",
    "# plt.savefig(f\"plots//{folder_name_plots}//Time_series_{dataset}.pdf\") \n",
    "\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize = (8,6))\n",
    "sns.heatmap(corr_df_mean, vmin = 0, vmax = 1 )\n",
    "# fig.suptitle(\"Correlation heatmaps of different files\")\n",
    "plt.title(\"Overall correltion heatmap: Mean\")\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"plots//{folder_name_plots}//Corr_Heatmap_Overall_{dataset}_Mean.jpg\", dpi = 350) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize = (8,6))\n",
    "sns.heatmap(corr_df_fisher, vmin = 0, vmax = 1 )\n",
    "# fig.suptitle(\"Correlation heatmaps of different files\")\n",
    "plt.title(\"Overall correltion heatmap: Z Fischer\")\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"plots//{folder_name_plots}//Corr_Heatmap_Overall_{dataset}_Fischer.jpg\", dpi = 350) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_of_Signals = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'corr_df_fisher' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 17\u001b[0m\n\u001b[1;32m     14\u001b[0m top_signals_df \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mDataFrame([])\n\u001b[1;32m     16\u001b[0m \u001b[39mfor\u001b[39;00m targeted_signal \u001b[39min\u001b[39;00m targeted_signals:\n\u001b[0;32m---> 17\u001b[0m     top_signals_df[targeted_signal] \u001b[39m=\u001b[39m corr_df_fisher[targeted_signal]\u001b[39m.\u001b[39msort_values(ascending\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\u001b[39m.\u001b[39mindex\n\u001b[1;32m     19\u001b[0m \u001b[39m# ......................\u001b[39;00m\n\u001b[1;32m     20\u001b[0m top_signals \u001b[39m=\u001b[39m targeted_signals\u001b[39m.\u001b[39mcopy()\n",
      "\u001b[0;31mNameError\u001b[0m: name 'corr_df_fisher' is not defined"
     ]
    }
   ],
   "source": [
    "if dataset == 'syncan':\n",
    "    top_signals = list(corr_df_fisher.columns)\n",
    "else:\n",
    "    # Opening attacked signals file\n",
    "    #-----------------------\n",
    "    f = open(cur_dir+f\"//Saved_Data//attacked_signals.json\")\n",
    "    attacked_signals = json.load(f)\n",
    "    f.close()\n",
    "    x = [] \n",
    "    for val in attacked_signals.values(): x +=val\n",
    "    targeted_signals = list(set(x))\n",
    "\n",
    "    # Top 20 signals........................\n",
    "    top_signals_df = pd.DataFrame([])\n",
    "\n",
    "    for targeted_signal in targeted_signals:\n",
    "        top_signals_df[targeted_signal] = corr_df_fisher[targeted_signal].sort_values(ascending=False).index\n",
    "\n",
    "    # ......................\n",
    "    top_signals = targeted_signals.copy()\n",
    "    row = 0\n",
    "    col = 0\n",
    "\n",
    "    while(len(top_signals) < num_of_Signals):\n",
    "\n",
    "        sig = top_signals_df.iloc[row, col]\n",
    "        #print(f\"{row}, {col} : {sig}\")\n",
    "        if sig not in top_signals:\n",
    "            top_signals.append(sig)\n",
    "    #         print(f\"Adding {sig}\")\n",
    "        col += 1  \n",
    "\n",
    "        if col == len(targeted_signals):\n",
    "            #print(\"going to the next row...\")\n",
    "            col = 0\n",
    "            row += 1      \n",
    "    #     print(len(top_signals))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#--------------------------------------------\n",
    "from scipy.cluster import hierarchy as sch\n",
    "from scipy.cluster.hierarchy import dendrogram\n",
    "\n",
    "fig, axes = plt.subplots(1, 3, figsize = (17, 5))\n",
    "\n",
    "#------------ Clustering again ---------------\n",
    "# Plotting the correlation matrix...........\n",
    "\n",
    "# corr_df_target = corr_df_fisher.copy()\n",
    "\n",
    "corr_df_target = corr_df_mean.copy()\n",
    "\n",
    "\n",
    "top_signals = rename_sigids(top_signals)\n",
    "corr_df_target = rename_sigids(corr_df_target)\n",
    "\n",
    "corr_df = abs(corr_df_target.loc[top_signals,top_signals]).copy()\n",
    "\n",
    "\n",
    "sns.heatmap(corr_df, ax = axes[0]) # unclustered version\n",
    "# plt.savefig(f\"plots/heatmap_before_{file_name}.jpg\", dpi = 500)\n",
    "# plt.show()\n",
    "axes[0].set_title(\"Correlation before clustering\")\n",
    "\n",
    "#--------------------------------------------\n",
    "corr_array = corr_df.copy()\n",
    "inplace = False\n",
    "pairwise_distances = sch.distance.pdist(corr_array)\n",
    "linkage = sch.linkage(pairwise_distances, method='complete')\n",
    "\n",
    "#--------------------------------------------\n",
    "# plt.figure(figsize=(5, 5)) \n",
    "axes[1].set_title(\"Dendrograms of hierarchical clustering\")\n",
    "dend = sch.dendrogram(linkage, orientation='right', labels=corr_df.index, ax =axes[1])\n",
    "#--------------------------------------------\n",
    "# Plotting the correlation matrix...........\n",
    "sns.heatmap(corr_df.loc[dend['ivl'][::-1], dend['ivl'][::-1]], ax = axes[2])\n",
    "axes[2].set_title(\"Correlation after clustering\")\n",
    "\n",
    "if dataset == 'syncan':\n",
    "    fig.suptitle(f\"Signal clustering and rearranging based on correlations: SynCAN dataset\")\n",
    "else:\n",
    "    fig.suptitle(f\"Signal clustering and rearranging based on correlations: ROAD dataset\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"plots//{folder_name_plots}//heatmap_before_after_den_{dataset}.jpg\", dpi = 500)\n",
    "plt.show()\n",
    "\n",
    "#Updating the columns sequence\n",
    "#--------------------------------------------\n",
    "# print(dend['ivl'][::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Top 50\n",
    "\n",
    "# list_of_sigs = dend['ivl'][::-1]\n",
    "# list_of_sigs\n",
    "# ['S:4_ID:0167',\n",
    "#  'S:2_ID:1505',\n",
    "#  'S:4_ID:1031',\n",
    "#  'S:1_ID:0051',\n",
    "#  'S:4_ID:0778',\n",
    "#  'S:8_ID:0778',\n",
    "#  'S:4_ID:1628',\n",
    "#  'S:2_ID:1255',\n",
    "#  'S:2_ID:0526',\n",
    "#  'S:1_ID:1760',\n",
    "#  'S:4_ID:1176',\n",
    "#  'S:6_ID:0208',\n",
    "#  'S:3_ID:1760',\n",
    "#  'S:4_ID:1760',\n",
    "#  'S:2_ID:1760',\n",
    "#  'S:1_ID:0167',\n",
    "#  'S:7_ID:0208',\n",
    "#  'S:5_ID:1590',\n",
    "#  'S:7_ID:1628',\n",
    "#  'S:9_ID:1413',\n",
    "#  'S:9_ID:0167',\n",
    "#  'S:8_ID:1455',\n",
    "#  'S:5_ID:0640',\n",
    "#  'S:2_ID:0852',\n",
    "#  'S:3_ID:0622',\n",
    "#  'S:2_ID:1398',\n",
    "#  'S:9_ID:1455',\n",
    "#  'S:3_ID:1076',\n",
    "#  'S:11_ID:1031',\n",
    "#  'S:10_ID:0470',\n",
    "#  'S:1_ID:0683',\n",
    "#  'S:2_ID:0778',\n",
    "#  'S:6_ID:0628',\n",
    "#  'S:6_ID:0167',\n",
    "#  'S:3_ID:0208',\n",
    "#  'S:1_ID:0852',\n",
    "#  'S:7_ID:1788',\n",
    "#  'S:2_ID:0051',\n",
    "#  'S:7_ID:0354',\n",
    "#  'S:3_ID:0996',\n",
    "#  'S:1_ID:1634',\n",
    "#  'S:2_ID:0208',\n",
    "#  'S:1_ID:0014',\n",
    "#  'S:3_ID:0014',\n",
    "#  'S:8_ID:0470',\n",
    "#  'S:2_ID:0061',\n",
    "#  'S:2_ID:0204',\n",
    "#  'S:3_ID:0458',\n",
    "#  'S:5_ID:1372',\n",
    "#  'S:5_ID:0631']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Top 10\n",
    "\n",
    "# list_of_sigs = dend['ivl'][::-1]\n",
    "# list_of_sigs\n",
    "# ['S:4_ID:1628',\n",
    "#  'S:2_ID:1255',\n",
    "#  'S:3_ID:1760',\n",
    "#  'S:6_ID:0208',\n",
    "#  'S:1_ID:1760',\n",
    "#  'S:4_ID:1760',\n",
    "#  'S:2_ID:1760',\n",
    "#  'S:5_ID:1590',\n",
    "#  'S:3_ID:0208',\n",
    "#  'S:3_ID:0014']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Top 5\n",
    "# # list_of_sigs = dend['ivl'][::-1]\n",
    "# # list_of_sigs\n",
    "# ['S:3_ID:1760',\n",
    "#  'S:6_ID:0208',\n",
    "#  'S:1_ID:1760',\n",
    "#  'S:4_ID:1760',\n",
    "#  'S:2_ID:1760',\n",
    "#  'S:2_ID:1255',\n",
    "#  'S:3_ID:0208']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
